package main

import (
    "bufio"
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
    "strings"
    "time"
)

type Message struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}

type Request struct {
    Model    string    `json:"model"`
    Messages []Message `json:"messages"`
}

type Response struct {
    Choices []struct {
        Message struct {
            Content string `json:"content"`
        } `json:"message"`
    } `json:"choices"`
}

type Config struct {
    AI struct {
        BaseURL string `json:"base_url"`
        Model   string `json:"model"`
        APIKey  string `json:"api_key"`
    } `json:"ai"`
    SavePath string `json:"save_path"`
}

var config Config

func loadConfig() error {
    // 首先尝试读取当前目录的配置文件
    configFile := "config.json"
    if _, err := os.Stat(configFile); os.IsNotExist(err) {
        // 如果配置文件不存在，创建默认配置
        defaultConfig := Config{
            AI: struct {
                BaseURL string `json:"base_url"`
                Model   string `json:"model"`
                APIKey  string `json:"api_key"`
            }{
                BaseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
                Model:   "qwen-plus",
                APIKey:  "sk-28e5a3bbcfe044d1a799b9571fe35b13",
            },
            SavePath: "reviews",
        }
        
        // 将默认配置写入文件
        jsonData, err := json.MarshalIndent(defaultConfig, "", "    ")
        if err != nil {
            return fmt.Errorf("生成默认配置失败: %v", err)
        }
        
        if err := ioutil.WriteFile(configFile, jsonData, 0644); err != nil {
            return fmt.Errorf("写入默认配置失败: %v", err)
        }
        
        config = defaultConfig
        return nil
    }

    // 读取配置文件
    data, err := ioutil.ReadFile(configFile)
    if err != nil {
        return fmt.Errorf("读取配置文件失败: %v", err)
    }

    // 解析配置
    if err := json.Unmarshal(data, &config); err != nil {
        return fmt.Errorf("解析配置文件失败: %v", err)
    }

    return nil
}

func getQuestions() ([]string, error) {
    prompt := `作为一个专业的复盘引导师，请生成5个引导性问题来帮助用户进行今天的复盘。要求：
1. 问题要具体且有启发性
2. 问题要覆盖：今日成果、遇到的挑战、收获感悟、改进空间、未来计划
3. 每个问题都要简洁明了
4. 问题要有序号
请直接输出5个问题，每行一个，前面带序号。`

    response, err := chatWithAI(prompt)
    if err != nil {
        return nil, err
    }

    // 将AI回答按行分割成问题数组
    questions := strings.Split(strings.TrimSpace(response), "\n")
    return questions, nil
}

func main() {
    // 加载配置
    if err := loadConfig(); err != nil {
        fmt.Printf("加载配置失败: %v\n", err)
        return
    }

    fmt.Println("\n=== 每日复盘助手 ===")
    fmt.Printf("日期：%s\n\n", time.Now().Format("2006-01-02"))
    fmt.Println("输入 'save' 保存并结束，输入 'quit' 不保存退出\n")

    // 获取AI生成的问题
    questions, err := getQuestions()
    if err != nil {
        fmt.Printf("获取问题时出错: %v\n", err)
        return
    }

    // 收集用户回答
    answers := make([]string, len(questions))
    scanner := bufio.NewScanner(os.Stdin)

    for i, question := range questions {
        fmt.Printf("%s\n答：", question)
        if !scanner.Scan() {
            return
        }
        
        input := scanner.Text()
        if input == "save" {
            // 将未回答的问题填充为空
            answers[i] = "未回答"
            for j := i + 1; j < len(questions); j++ {
                answers[j] = "未回答"
            }
            // 生成分析并保存
            saveAndAnalyze(questions, answers)
            return
        } else if input == "quit" {
            fmt.Println("已取消复盘")
            return
        }
        
        answers[i] = input
    }

    // 所有问题回答完毕，询问是否保存
    fmt.Print("\n所有问题已回答完毕。是否保存？(y/N): ")
    var response string
    fmt.Scanln(&response)
    if strings.ToLower(response) == "y" {
        saveAndAnalyze(questions, answers)
    } else {
        fmt.Println("已取消保存")
    }
}

func saveAndAnalyze(questions []string, answers []string) {
    // 生成复盘总结请求
    prompt := fmt.Sprintf(`作为一个专业的复盘助手，请帮我分析今天的复盘内容并给出建议：

今日复盘内容：
%s

请从以下几个方面进行分析和建议：
1. 对已完成事项的评价
2. 对遇到挑战的解决建议
3. 对未来计划的优化建议
4. 个人成长的建议

请给出具体、可执行的建议。`, formatAnswers(questions, answers))

    // 获取AI分析
    response, err := chatWithAI(prompt)
    if err != nil {
        fmt.Printf("获取分析时出错: %v\n", err)
        return
    }

    // 保存复盘记录
    saveReview(questions, answers, response)

    fmt.Println("\n=== AI 分析与建议 ===")
    fmt.Println(response)
    fmt.Println("\n复盘记录已保存")
}

func formatAnswers(questions []string, answers []string) string {
    var result strings.Builder
    for i, question := range questions {
        result.WriteString(fmt.Sprintf("%s\n答：%s\n\n", question, answers[i]))
    }
    return result.String()
}

func chatWithAI(prompt string) (string, error) {
    messages := []Message{
        {Role: "user", Content: prompt},
    }

    requestBody := Request{
        Model:    config.AI.Model,
        Messages: messages,
    }

    jsonData, err := json.Marshal(requestBody)
    if err != nil {
        return "", fmt.Errorf("JSON编码错误: %v", err)
    }

    req, err := http.NewRequest("POST", config.AI.BaseURL+"/chat/completions", bytes.NewBuffer(jsonData))
    if err != nil {
        return "", fmt.Errorf("创建请求失败: %v", err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer "+config.AI.APIKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", fmt.Errorf("发送请求失败: %v", err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return "", fmt.Errorf("读取响应失败: %v", err)
    }

    if resp.StatusCode != http.StatusOK {
        return "", fmt.Errorf("API请求失败，状态码: %d，响应: %s", resp.StatusCode, string(body))
    }

    var response Response
    if err := json.Unmarshal(body, &response); err != nil {
        return "", fmt.Errorf("解析响应失败: %v", err)
    }

    if len(response.Choices) == 0 {
        return "", fmt.Errorf("AI没有返回答案")
    }

    return response.Choices[0].Message.Content, nil
}

func saveReview(questions []string, answers []string, aiAnalysis string) {
    now := time.Now()
    
    // 使用配置的保存路径
    monthDir := fmt.Sprintf("%s/%s/%02d", config.SavePath, now.Format("2006"), now.Month())
    if err := os.MkdirAll(monthDir, 0755); err != nil {
        fmt.Printf("创建月份目录失败: %v\n", err)
        return
    }

    // 生成包含时分的文件名
    filename := fmt.Sprintf("%s/review_%s.html", 
        monthDir,
        now.Format("2006-01-02_15-04"))

    // HTML模板
    htmlTemplate := `
<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>每日复盘 - %s</title>
    <style>
        body {
            font-family: 'Microsoft YaHei', Arial, sans-serif;
            line-height: 1.6;
            max-width: 800px;
            margin: 0 auto;
            padding: 20px;
            background-color: #f5f5f5;
        }
        .container {
            background-color: white;
            padding: 30px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
        }
        h1 {
            color: #2c3e50;
            text-align: center;
            border-bottom: 2px solid #eee;
            padding-bottom: 10px;
        }
        .date {
            text-align: center;
            color: #666;
            margin-bottom: 30px;
        }
        .section {
            margin-bottom: 25px;
        }
        .section-title {
            color: #2c3e50;
            font-size: 1.2em;
            font-weight: bold;
            margin-bottom: 10px;
        }
        .content {
            background-color: #f9f9f9;
            padding: 15px;
            border-radius: 5px;
            border-left: 4px solid #3498db;
        }
        .ai-analysis {
            margin-top: 40px;
            padding: 20px;
            background-color: #f0f7ff;
            border-radius: 5px;
        }
        .ai-analysis h2 {
            color: #2980b9;
            margin-top: 0;
        }
        .file-info {
            text-align: right;
            color: #666;
            font-size: 0.9em;
            margin-top: 20px;
            padding-top: 20px;
            border-top: 1px solid #eee;
        }
        .breadcrumb {
            color: #666;
            font-size: 0.9em;
            margin-bottom: 20px;
        }
        .breadcrumb a {
            color: #3498db;
            text-decoration: none;
        }
        .breadcrumb a:hover {
            text-decoration: underline;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="breadcrumb">
            位置：%s年 / %s月 / %s
        </div>
        <h1>每日复盘记录</h1>
        <div class="date">%s</div>

        <div class="section">
            <div class="section-title">复盘问答</div>
            %s
        </div>

        <div class="ai-analysis">
            <h2>AI 分析与建议</h2>
            <div class="content">%s</div>
        </div>

        <div class="file-info">
            创建时间：%s
        </div>
    </div>
</body>
</html>
`

    // 格式化问答内容
    var qaContent strings.Builder
    for i, question := range questions {
        qaContent.WriteString(fmt.Sprintf(`
            <div class="content" style="margin-bottom: 15px">
                <div style="color: #2c3e50; margin-bottom: 8px">%s</div>
                <div>%s</div>
            </div>
        `, question, strings.ReplaceAll(answers[i], "\n", "<br>")))
    }

    // 处理换行符
    aiAnalysis = strings.ReplaceAll(aiAnalysis, "\n", "<br>")
    
    // 格式化HTML内容
    htmlContent := fmt.Sprintf(
        htmlTemplate,
        now.Format("2006-01-02 15:04"),        // 标题
        now.Format("2006"),                     // 年份
        now.Format("01"),                       // 月份
        now.Format("2006-01-02 15:04"),        // 文件名
        now.Format("2006年01月02日 15:04"),     // 显示日期
        qaContent.String(),                     // 问答内容
        aiAnalysis,                             // AI分析
        now.Format("2006-01-02 15:04:05"),     // 创建时间
    )

    // 写入文件
    err := ioutil.WriteFile(filename, []byte(htmlContent), 0644)
    if err != nil {
        fmt.Printf("保存复盘记录失败: %v\n", err)
        return
    }

    fmt.Printf("\n复盘记录已保存至: %s\n", filename)
} 